JavaScript 数组去重

（点击上方公众号，可快速关注）

来源：沉静地闪光

https://segmentfault.com/a/1190000016418021

数组去重，一般都是在面试的时候才会碰到，一般是要求手写数组去重方法的代码。如果是被提问到，数组去重的方法有哪些？你能答出其中的10种，面试官很有可能对你刮目相看。

在真实的项目中碰到的数组去重，一般都是后台去处理，很少让前端处理数组去重。虽然日常项目用到的概率比较低，但还是需要了解一下，以防面试的时候可能回被问到。

一、利用ES6 Set去重（ES6中最常用）

1.    function unique (arr) {

2.      return Array.from(new Set(arr))

3.    }

4.    var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];

5.    console.log(unique(arr))

6.     //[1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {}, {}]

不考虑兼容性，这种去重的方法代码最少。这种方法还无法去掉“{}”空对象，后面的高阶方法会添加去掉“{}”空对象。

二、利用for嵌套for，然后splice去重（ES5中最常用）

1.    function unique(arr){            

2.            for(var i=0; i<arr.length; i++){

3.                for(var j=i+1; j<arr.length; j++){

4.                    if(arr[i]==arr[j]){         //第一个等同于第二个，splice方法删除第二个

5.                        arr.splice(j,1);

6.                        j--;

7.                    }

8.                }

9.            }

10.    return arr;

11.    }

12.    var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];

13.        console.log(unique(arr))

14.        //[1, "true", 15, false, undefined, NaN, NaN, "NaN", "a", {…}, {…}]

双层循环，外层循环元素，内层循环时比较值。值相同时，则删去这个值。

想快速学习更多常用的ES6语法，可以看我之前的文章《学习ES6笔记──工作中常用到的ES6语法》（https://segmentfault.com/a/1190000016068235）。

三、利用indexOf去重

1.    function unique(arr) {

2.        if (!Array.isArray(arr)) {

3.            console.log('type error!')

4.            return

5.        }

6.        var array = [];

7.        for (var i = 0; i < arr.length; i++) {

8.            if (array .indexOf(arr[i]) === -1) {

9.                array .push(arr[i])

10.            }

11.        }

12.        return array;

13.    }

新建一个空的结果数组，for 循环原数组，判断结果数组是否存在当前元素，如果有相同的值则跳过，不相同则push进数组。

四、利用sort()

1.    function unique(arr) {

2.        if (!Array.isArray(arr)) {

3.            console.log('type error!')

4.            return;

5.        }

6.        arr = arr.sort()

7.        var arrry= [arr[0]];

8.        for (var i = 1; i < arr.length; i++) {

9.            if (arr[i] !== arr[i-1]) {

10.                arrry.push(arr[i]);

11.            }

12.        }

13.        return arrry;

14.    }

利用sort()排序方法，然后根据排序后的结果进行遍历及相邻元素比对。

五、利用对象的属性不能相同的特点进行去重

1.    function unique(arr) {

2.        if (!Array.isArray(arr)) {

3.            console.log('type error!')

4.            return

5.        }

6.        var arrry= [];

7.         var  obj = {};

8.        for (var i = 0; i < arr.length; i++) {

9.            if (!obj[arr[i]]) {

10.                arrry.push(arr[i])

11.                obj[arr[i]] = 1

12.            } else {

13.                obj[arr[i]]++

14.            }

15.        }

16.        return arrry;

17.    }

六、利用includes

1.    function unique(arr) {

2.        if (!Array.isArray(arr)) {

3.            console.log('type error!')

4.            return

5.        }

6.        var arrry=[];

7.        for(vari = 0; i < arr.length; i++) {

8.                if( !arrry.includes( arr[i]) ) {//includes 检测数组是否有某个值

9.                        arrry.push(arr[i]);

10.                  }

11.        }

12.    }

七、利用hasOwnProperty

1.    function unique(arr) {

2.        var obj = {};

3.        return arr.filter(function(item, index, arr){

4.            return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)

5.        })

6.    }

利用hasOwnProperty 判断是否存在对象属性。

八、利用filter

1.    function unique(arr) {

2.      return arr.filter(function(item, index, arr) {

3.        //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素

4.        return arr.indexOf(item, 0) === index;

5.      });

6.    }

九、利用递归去重

1.    function unique(arr) {

2.            var arrry= arr;

3.            var len = arrry.length;

4.        arrry.sort(function(a,b){   //排序后更加方便去重

5.            return a - b;

6.        })

7.        function loop(index){

8.            if(index >= 1){

9.                if(arrry[index] === arrry[index-1]){

10.                    arrry.splice(index,1);

11.                }

12.                loop(index - 1);    //递归loop，然后数组去重

13.            }

14.        }

15.        loop(len-1);

16.        return arrry;

17.    }

十、利用Map数据结构去重

1.    function arrayNonRepeatfy(arr) {

2.      let map = new Map();

3.      let array = new Array();  // 数组用于返回结果

4.      for (let i = 0; i < arr.length; i++) {

5.        if(map .has(arr[i])) {  // 如果有该key值

6.          map .set(arr[i], true);

7.        } else {

8.          map .set(arr[i], false);   // 如果没有该key值

9.          array .push(arr[i]);

10.        }

11.      }

12.      return array ;

13.    }

创建一个空Map数据结构，遍历需要去重的数组，把数组的每一个元素作为key存到Map中。由于Map中不会出现相同的key值，所以最终得到的就是去重后的结果。

十一、利用reduce

1.    Array.prototype.unique = function() {

2.      var sortArr = this.sort();

3.      var array = [];

4.      sortArr.reduce((s1,s2) => {

5.        if(s1 !== s2){

6.          array .push(s1);

7.        }

8.        return s2;

9.      })

10.      array .push(sortArr[sortArr.length - 1]);

11.      return array ;

12.    }

十二、[...new Set(arr)]

1.    [...new Set(arr)]

2.    //代码就是这么少----（其实，严格来说并不算是一种，相对于第一种方法来说只是简化了代码）

PS：有些文章提到了 foreach+indexOf 数组去重的方法，个人觉得都是大同小异，所以没有写上去。

【关于投稿】

如果大家有原创好文投稿，请直接给公号发送留言。

① 留言格式：
【投稿】+《 文章标题》+ 文章链接

② 示例：
【投稿】《不要自称是程序员，我十多年的 IT 职场总结》：http://blog.jobbole.com/94148/

③ 最后请附上您的个人简介哈~

觉得本文对你有帮助？请分享给更多人

关注「前端大全」，提升前端技能